<template>
  <view>
    <!-- 遮罩层：强制更新时全屏遮挡，禁止操作其他内容 -->
    <view
      class="update-mask"
      v-show="showDialog || progressVisible || showRestartTip"
      :class="{ 'mask-force': force }"
      @click="handleMaskClick"
    ></view>

    <!-- 主弹窗容器：仅在非重启提示时显示 -->
    <view v-show="showDialog && !showRestartTip" class="update-dialog">
      <!-- 弹窗标题：强制更新时增加红色强调，跨版本时显示警告标题 -->
      <view
        class="update-title"
        :class="{ 'title-force': force || isCrossVersion }"
        >{{ title }}</view
      >

      <!-- 支持 <p> 标签渲染，跨版本时显示兼容性提示 -->
      <view
        class="update-content"
        v-html="content || '优化应用体验，修复已知问题'"
      ></view>

      <!-- 下载进度条 + 百分比 -->
      <view v-if="progressVisible" class="update-progress">
        <view class="progress-bg">
          <view class="progress-bar" :style="{ width: progress + '%' }"></view>
        </view>
        <text>{{ progress }}%</text>
      </view>

      <!-- 弹窗按钮：进度条/重启提示显示时隐藏 -->
      <view class="update-actions" v-if="!progressVisible && !showRestartTip">
        <button
          v-if="!force && !isCrossVersion"
          @click="cancelUpdate"
          :disabled="isHandlingUpdate"
        >
          {{ cancelText }}
        </button>
        <button
          @click="confirmUpdate"
          :class="{ 'btn-force': force || isCrossVersion }"
          :disabled="isHandlingUpdate"
        >
          {{ getConfirmBtnText() }}
        </button>
      </view>
    </view>

    <!-- 独立重启提示：替代原弹窗内提示，便于单独控制隐藏 -->
    <view v-show="showRestartTip" class="restart-tip">
      <view class="restart-icon">⟳</view>
      <view class="restart-text">{{ restartTipText }}</view>
    </view>
  </view>
</template>

<script>
import CONFIG from "./config/index.js";
import {
  downloadAndInstallApk,
  downloadAndInstallWgt,
  openAppStore
} from "./utils/updateUtils.js";

export default {
  name: "UpdateCheck",
  props: {
    cancelText: { type: String, default: "取消" },
    updateText: { type: String, default: "更新" },
    forceText: { type: String, default: "立即更新" },
    storeText: { type: String, default: "去应用商店更新" },
    restartTipText: { type: String, default: "更新完成，应用即将重启..." } // 可自定义重启提示
  },
  data() {
    return {
      showToast: (msg) =>
        uni.showToast({ title: msg, icon: "none", duration: 1800, mask: true }),
      showDialog: true, // 主弹窗显示状态
      title: "更新提示", // 主弹窗标题
      content: "", // 主弹窗内容
      force: false, // 是否强制更新
      progressVisible: false, // 进度条显示状态
      progress: 0, // 下载进度
      downloadUrls: [], // 有效更新地址
      downloadType: "wgt", // 更新类型（wgt/apk/store）
      isHandlingUpdate: false, // 防止重复点击
      // 跨版本更新相关
      isCrossVersion: false, // 是否跨版本不兼容
      minSupportApkVer: "0.0.0", // WGT支持的最低APK版本
      maxSupportApkVer: "999.999.999", // WGT支持的最高APK版本
      // 核心修复：独立重启提示状态
      showRestartTip: false, // 独立重启提示显示状态
      restartTimer: null, // 重启定时器（用于清理）
      // 新增：本地应用信息缓存（避免重复调用plus.runtime.getProperty）
      localAppInfo: null
    };
  },
  onLoad(options) {
    // 页面加载时重置所有状态（避免重启后残留）
    this.resetAllStates();
    let updateInfo = {};
    if (options.updateInfo) {
      try {
        updateInfo = JSON.parse(decodeURIComponent(options.updateInfo));
        console.log("解析到的更新信息：", updateInfo);
      } catch (err) {
        console.error("解析更新信息失败：", err);
        this.showToast("更新信息解析异常，请重试");
        this.showDialog = false;
        return;
      }
    }
    // 修复：先获取本地应用信息，再执行更新逻辑（确保版本取值正确）
    this.getLocalAppInfo()
      .then((localAppInfo) => {
        this.localAppInfo = localAppInfo;
        this.startUpdate(updateInfo);
      })
      .catch((err) => {
        console.error("获取本地应用信息失败：", err);
        this.showToast("无法获取本地版本信息，更新失败");
        this.showDialog = false;
      });
  },
  onUnload() {
    // 页面卸载时清理定时器（防止内存泄漏）
    if (this.restartTimer) {
      clearTimeout(this.restartTimer);
      this.restartTimer = null;
    }
  },
  onBackPress() {
    // 强制更新/跨版本/重启提示时禁止返回
    if (this.force || this.isCrossVersion || this.showRestartTip) {
      this.showToast(
        this.showRestartTip ? "应用即将重启，请勿退出" : "请先完成更新"
      );
      return true;
    }
  },
  onShow() {
    // 重启后若仍有残留状态，强制重置
    if (this.showRestartTip) {
      this.showRestartTip = false;
    }
    if (this.force || this.isCrossVersion) {
      this.showDialog = true;
    }
  },
  methods: {
    // 重置所有状态（用于页面加载和异常场景）
    resetAllStates() {
      this.showDialog = true;
      this.progressVisible = false;
      this.progress = 0;
      this.isHandlingUpdate = false;
      this.isCrossVersion = false;
      this.showRestartTip = false;
      this.localAppInfo = null; // 重置本地应用信息缓存
      if (this.restartTimer) {
        clearTimeout(this.restartTimer);
        this.restartTimer = null;
      }
    },

    /**
     * 【核心修复1】获取本地应用信息（Promise封装，确保版本取值正确）
     * @returns {Promise<Object>} 本地应用信息（含versionName/versionCode）
     */
    getLocalAppInfo() {
      return new Promise((resolve, reject) => {
        if (typeof plus === "undefined") {
          reject(new Error("非App环境，无法获取应用信息"));
          return;
        }
        // 正确调用plus.runtime.getProperty：通过appid获取应用信息
        plus.runtime.getProperty(plus.runtime.appid, (appInfo) => {
          if (!appInfo) {
            reject(new Error("获取应用信息为空"));
            return;
          }
          // 标准化本地应用信息：统一字段命名，避免混淆
          const standardAppInfo = {
            // 版本名（如1.0.0，用于显示和跨版本校验）
            versionName:
              appInfo.version ||
              appInfo.versionName ||
              CONFIG.defaultVersion ||
              "0.0.0",
            // 版本码（如100，用于数字对比，优先取versionCode，无则从versionName转换）
            versionCode: this.getLocalVersionCode(appInfo),
            // 原始信息缓存（备用）
            raw: appInfo
          };
          console.log("标准化本地应用信息：", standardAppInfo);
          resolve(standardAppInfo);
        });
      });
    },

    /**
     * 【核心修复2】获取本地版本码（处理不同UniApp版本的字段差异）
     * @param {Object} appInfo - plus.runtime.getProperty返回的原始信息
     * @returns {Number} 标准化版本码（如100）
     */
    getLocalVersionCode(appInfo) {
      // 1. 优先使用原生versionCode（Android标准字段）
      if (appInfo.versionCode != null && appInfo.versionCode !== "") {
        try {
          return parseInt(
            appInfo.versionCode.toString().replace(/[^\d]/g, ""),
            10
          );
        } catch (err) {
          console.warn(
            "解析versionCode失败， fallback到versionName转换：",
            err
          );
        }
      }
      // 2. 无versionCode时，从versionName转换（如1.0.0 → 100）
      const versionName = appInfo.version || appInfo.versionName || "0.0.0";
      const sanitizedVer = this.sanitizeVersion(versionName);
      const verParts = sanitizedVer.split(".").map((part) => {
        // 每个版本段补0至2位（如1 → 01，10 →10），避免1.0.0 vs 1.0.10的数字对比错误
        return part.padStart(2, "0");
      });
      // 合并为3段（不足补00），转换为数字（如1.0.0 → 010000 → 10000，1.0.10 → 010010 → 10010）
      const verCodeStr = [...verParts.slice(0, 3), "00", "00"]
        .slice(0, 3)
        .join("");
      return parseInt(verCodeStr, 10) || 0;
    },

    // 清理版本号（仅用于版本名，版本码用getLocalVersionCode处理）
    sanitizeVersion(v) {
      if (!v || typeof v !== "string") return "0.0.0";
      let ver = v.trim().replace(/[^\d.]/g, ""); // 保留数字和点
      ver = ver.replace(/^\.+|\.+$/g, "").replace(/\.{2,}/g, "."); // 清理首尾点和多点点
      return ver ? ver : "0.0.0";
    },

    // 比较版本号（仅用于版本名对比，版本码用数字直接对比）
    compareVersion(v1, v2) {
      v1 = this.sanitizeVersion(v1);
      v2 = this.sanitizeVersion(v2);
      const v1Parts = v1.split(".").map(Number);
      const v2Parts = v2.split(".").map(Number);
      const maxLen = Math.max(v1Parts.length, v2Parts.length);

      for (let i = 0; i < maxLen; i++) {
        const n1 = v1Parts[i] || 0;
        const n2 = v2Parts[i] || 0;
        if (n1 > n2) return 1;
        if (n1 < n2) return -1;
      }
      return 0;
    },

    /**
     * 核心入口：跨版本校验（修复本地版本取值）
     * @param {Object} updateInfo - 远程更新信息
     */
    startUpdate(updateInfo = {}) {
      // 先校验本地应用信息是否获取成功
      if (!this.localAppInfo) {
        this.showDialog = false;
        this.showToast("本地版本信息获取失败，无法更新");
        return;
      }
      // 从标准化的localAppInfo中取值（修复核心问题）
      const { versionName: localApkVer, versionCode: localNumber } =
        this.localAppInfo;
      console.log("本地版本信息（修复后）：", { localApkVer, localNumber });

      // 解构远程更新信息（含跨版本字段）
      const {
        edition_urls = [],
        package_type = 1,
        edition_force = 0,
        edition_silence = 0,
        describe = "",
        edition_name = "0.0.0", // 远程版本名（如1.0.0）
        edition_number = "100", // 远程版本码（如100）
        edition_open_store = 0,
        min_support_apk_version = "0.0.0",
        max_support_apk_version = "999.999.999"
      } = updateInfo || {};

      // 过滤有效地址（增加空字符串判断）
      const validEditionUrls = (() => {
        if (typeof edition_urls === "string") {
          return edition_urls.trim() ? [edition_urls.trim()] : [];
        }
        return Array.isArray(edition_urls)
          ? edition_urls.filter(
              (url) => url && typeof url === "string" && url.trim()
            )
          : [];
      })();

      // 【修复3】解析远程版本号（与本地版本处理逻辑对齐）
      const remoteNumber = this.parseRemoteVersionCode(
        edition_number,
        edition_name
      );
      const remoteWgtVer = this.sanitizeVersion(edition_name);
      console.log("远程版本信息（标准化后）：", { remoteWgtVer, remoteNumber });

      // 【修复4】正确判断是否需要更新（版本码优先，版本名兜底）
      const isNeedUpdate = this.judgeNeedUpdate({
        validUrls: validEditionUrls,
        localNumber,
        remoteNumber,
        localVer: localApkVer,
        remoteVer: remoteWgtVer
      });

      if (!isNeedUpdate) {
        this.handleNoUpdate(edition_force, localApkVer);
        return;
      }

      // WGT跨版本兼容性校验（使用修复后的本地版本名）
      if (package_type === 1) {
        this.minSupportApkVer = this.sanitizeVersion(min_support_apk_version);
        this.maxSupportApkVer = this.sanitizeVersion(max_support_apk_version);
        const isApkCompatible =
          this.compareVersion(localApkVer, this.minSupportApkVer) >= 0 &&
          this.compareVersion(localApkVer, this.maxSupportApkVer) <= 0;

        if (!isApkCompatible) {
          this.handleCrossVersionIncompatible(localApkVer);
          return;
        }
      }

      // 静默更新（使用修复后的本地版本信息）
      if (package_type === 1 && edition_silence === 1) {
        this.showToast("开始静默更新...");
        this.progressVisible = true;
        this.downloadType = "wgt";
        this.downloadUrls = validEditionUrls;
        this.downloadAndInstall(this.downloadUrls, "wgt");
        return;
      }

      // 正常更新初始化
      this.initNormalUpdateState({
        describe,
        edition_force,
        package_type,
        edition_open_store,
        validEditionUrls,
        remoteWgtVer
      });
    },

    /**
     * 【新增】解析远程版本码（与本地版本码处理逻辑对齐，确保对比公平）
     * @param {string|number} remoteEditionNumber - 远程版本码字段（如"100"）
     * @param {string} remoteEditionName - 远程版本名字段（如"1.0.0"）
     * @returns {Number} 标准化远程版本码
     */
    parseRemoteVersionCode(remoteEditionNumber, remoteEditionName) {
      // 1. 优先使用远程传递的edition_number
      if (remoteEditionNumber != null && remoteEditionNumber !== "") {
        try {
          return parseInt(
            remoteEditionNumber.toString().replace(/[^\d]/g, ""),
            10
          );
        } catch (err) {
          console.warn(
            "解析远程edition_number失败，fallback到版本名转换：",
            err
          );
        }
      }
      // 2. 无edition_number时，从edition_name转换（与本地逻辑一致）
      const sanitizedVer = this.sanitizeVersion(remoteEditionName);
      const verParts = sanitizedVer
        .split(".")
        .map((part) => part.padStart(2, "0"));
      const verCodeStr = [...verParts.slice(0, 3), "00", "00"]
        .slice(0, 3)
        .join("");
      return parseInt(verCodeStr, 10) || 0;
    },

    /**
     * 【新增】判断是否需要更新（标准化逻辑，避免重复代码）
     * @param {Object} params - 版本对比参数
     * @returns {boolean} 是否需要更新
     */
    judgeNeedUpdate({
      validUrls,
      localNumber,
      remoteNumber,
      localVer,
      remoteVer
    }) {
      if (validUrls.length === 0) return false; // 无有效地址不更新

      // 版本码对比（数字对比，优先级最高）
      if (localNumber > 0 && remoteNumber > 0) {
        const isCodeNeedUpdate = remoteNumber > localNumber;
        console.log(
          `版本码对比：本地=${localNumber}，远程=${remoteNumber}，是否需要更新=${isCodeNeedUpdate}`
        );
        return isCodeNeedUpdate;
      }

      // 版本名对比（字符串分割对比，兜底）
      const isVerNeedUpdate = this.compareVersion(remoteVer, localVer) > 0;
      console.log(
        `版本名对比：本地=${localVer}，远程=${remoteVer}，是否需要更新=${isVerNeedUpdate}`
      );
      return isVerNeedUpdate;
    },

    // 处理无需更新（使用修复后的本地版本名）
    handleNoUpdate(edition_force, localApkVer) {
      if (!edition_force) {
        this.showDialog = false;
        this.showToast("当前已是最新版本");
      } else {
        this.content = `<p>当前APK版本（v${localApkVer}）已是最新</p><p>请确认后继续使用</p>`;
        this.force = true;
        this.isCrossVersion = false;
        this.showDialog = true;
      }
    },

    // 处理跨版本不兼容（使用修复后的本地版本名）
    handleCrossVersionIncompatible(localApkVer) {
      this.isCrossVersion = true;
      this.force = true;
      this.downloadType = "store";
      this.downloadUrls = [];
      this.title = "⚠️ 版本不兼容";
      this.content = `<p>当前应用版本过低（v${localApkVer}）</p>
                     <p>需先更新至 v${this.minSupportApkVer}~v${this.maxSupportApkVer} 基础版本</p>
                     <p>点击下方按钮跳转应用商店更新</p>`;
      this.showDialog = true;
    },

    // 初始化正常更新状态
    initNormalUpdateState({
      describe,
      edition_force,
      package_type,
      edition_open_store,
      validEditionUrls,
      remoteWgtVer
    }) {
      this.isCrossVersion = false;
      this.content = describe
        ? this.formatDescribe(describe)
        : `<p>发现新版本（v${remoteWgtVer}）</p><p>优化应用体验，修复已知问题</p>`;
      this.force = !!edition_force;
      this.downloadUrls = validEditionUrls;
      this.title = this.force ? "强制更新提示" : "更新提示";

      if (package_type === 0) {
        this.downloadType = edition_open_store ? "store" : "apk";
        this.downloadUrls = edition_open_store ? [] : validEditionUrls;
      } else {
        this.downloadType = "wgt";
      }

      this.showDialog = true;
    },

    // 格式化更新描述
    formatDescribe(describe) {
      if (typeof describe !== "string") return "";
      return describe.includes("<p>")
        ? describe
        : `<p>${describe.replace(/\n/g, "</p><p>")}</p>`;
    },

    // 获取确认按钮文本
    getConfirmBtnText() {
      if (this.isCrossVersion) return this.storeText;
      if (this.force) return this.forceText;
      if (this.downloadType === "store") return this.storeText;
      return this.updateText;
    },

    // 用户取消
    cancelUpdate() {
      if (this.force || this.isCrossVersion || this.showRestartTip) return;
      this.resetAllStates();
      this.showToast("已取消更新");
    },

    // 用户确认
    confirmUpdate() {
      if (this.isHandlingUpdate || this.showRestartTip) return;
      this.isHandlingUpdate = true;

      // 跨版本/商店更新：直接跳转
      if (this.downloadType === "store" || this.isCrossVersion) {
        this.handleStoreJump();
        return;
      }

      // 普通下载更新：显示进度条
      if (this.downloadUrls.length) {
        this.progressVisible = true;
        this.progress = 0;
        this.downloadAndInstall(this.downloadUrls, this.downloadType);
      } else {
        this.showToast("更新地址异常");
        this.isHandlingUpdate = false;
      }
    },

    // 跳转应用商店
    handleStoreJump() {
      try {
        openAppStore((err) => {
          console.error("打开应用商店失败：", err);
          this.showToast("打开应用商店失败，请手动搜索");
        });
        this.showToast("已跳转应用商店，请手动更新", 2000);
        // 非强制场景：跳转后关闭弹窗
        if (!this.force && !this.isCrossVersion) {
          setTimeout(() => {
            this.showDialog = false;
          }, 1500);
        }
      } catch (err) {
        console.error("应用商店跳转异常：", err);
        this.showToast("打开应用商店失败，请手动搜索");
      } finally {
        this.isHandlingUpdate = false;
        this.progressVisible = false;
      }
    },

    // 下载并安装：核心修复重启提示隐藏
    downloadAndInstall(urls, type) {
      if (!urls || !urls.length) {
        this.showToast("更新地址异常");
        this.isHandlingUpdate = false;
        this.progressVisible = false;
        return;
      }

      // 进度回调
      const onProgress = (p) => {
        this.progress = Math.max(0, Math.min(100, Math.floor(p)));
      };

      // 完成回调：核心修复点
      const onComplete = () => {
        // 1. 立即隐藏主弹窗和进度条
        this.showDialog = false;
        this.progressVisible = false;
        this.progress = 0;
        this.isHandlingUpdate = false;

        // 2. 仅WGT更新需要重启提示（APK无需）
        if (type === "wgt") {
          // 显示独立重启提示
          this.showRestartTip = true;
          // 3. 重启前100ms强制隐藏提示（确保重启时无残留）
          this.restartTimer = setTimeout(() => {
            try {
              this.showRestartTip = false; // 重启前隐藏提示
              plus.runtime.restart();
            } catch (e) {
              console.error("应用重启失败：", e);
              this.showRestartTip = false; // 重启失败也隐藏提示
              this.showToast("更新完成，请手动重启应用");
              // 非强制更新：失败后允许关闭
              if (!this.force) {
                this.showDialog = false;
              }
            }
          }, 1500); // 提示1.5秒后重启
        }
        // APK更新：无重启提示，直接引导安装
        else if (type === "apk") {
          this.showToast("安装包下载完成，正在准备安装...");
          setTimeout(() => {
            try {
              // 修复：APK路径需从下载回调获取，而非原始地址（若updateUtils返回路径）
              // 注：若downloadAndInstallApk返回安装包本地路径，需替换为该路径
              const apkLocalPath = urls[0]; // 若updateUtils返回路径，需改为回调参数
              plus.runtime.openFile(
                apkLocalPath,
                { showMenu: false },
                (err) => {
                  console.error("APK打开失败:", err);
                  this.showToast("安装失败，请手动安装");
                }
              );
            } catch (e) {
              console.error("APK安装接口异常:", e);
              this.showToast("安装包异常，请重新下载");
            }
          }, 1000);
        }
      };

      // 错误回调：重置状态
      const onError = (err) => {
        this.showDialog = true; // 错误时显示主弹窗
        this.progressVisible = false;
        this.progress = 0;
        this.isHandlingUpdate = false;
        this.showRestartTip = false; // 隐藏重启提示

        // 多地址重试
        if (urls.length > 1) {
          const nextUrls = urls.slice(1);
          console.warn(
            `当前地址失败，尝试下一个（剩余${nextUrls.length}个）`,
            err
          );
          this.downloadAndInstall(nextUrls, type);
          return;
        }

        this.showToast("更新失败，请稍后重试");
        console.error("更新错误：", err);
      };

      // 执行下载
      if (type === "wgt") {
        downloadAndInstallWgt(urls, onProgress, onComplete, onError);
      } else if (type === "apk") {
        downloadAndInstallApk(urls, onProgress, onComplete, onError);
      }
    },

    // 遮罩点击事件
    handleMaskClick() {
      if (!this.force && !this.isCrossVersion && !this.showRestartTip) {
        this.cancelUpdate();
      } else {
        const tip = this.showRestartTip
          ? "应用即将重启，请勿退出"
          : this.isCrossVersion
          ? "请先更新基础版本"
          : "请完成更新后继续使用";
        this.showToast(tip);
      }
    }
  }
};
</script>

<style scoped>
/* 遮罩层样式 */
.update-mask {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background-color: rgba(0, 0, 0, 0.5);
  z-index: 9998;
  touch-action: none;
}
.mask-force {
  background-color: rgba(0, 0, 0, 0.6);
  cursor: not-allowed;
}

/* 主弹窗容器 */
.update-dialog {
  position: fixed;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  width: 80%;
  max-width: 320px;
  background-color: #fff;
  padding: 22px 18px;
  border-radius: 8px;
  box-shadow: 0 3px 12px rgba(0, 0, 0, 0.15);
  z-index: 9999;
}

/* 弹窗标题 */
.update-title {
  font-size: 17px;
  font-weight: 600;
  color: #1a1a1a;
  margin-bottom: 16px;
  text-align: center;
}
.title-force {
  color: #ff4d4f !important;
}

/* 弹窗内容 */
.update-content {
  font-size: 14px;
  line-height: 1.7;
  margin-bottom: 18px;
  color: #666;
  min-height: 44px;
}
.update-content p {
  margin: 6px 0;
  white-space: normal;
}

/* 进度条样式 */
.update-progress {
  display: flex;
  align-items: center;
  gap: 10px;
  margin-bottom: 18px;
}
.progress-bg {
  flex-grow: 1;
  height: 6px;
  background-color: #f2f2f2;
  border-radius: 3px;
  overflow: hidden;
}
.progress-bar {
  height: 100%;
  background-color: #007aff !important;
  border-radius: 3px;
  transition: width 0.3s ease;
}
.update-progress text {
  font-size: 14px;
  color: #007aff;
  min-width: 40px;
  text-align: right;
}

/* 按钮样式 */
.update-actions {
  display: flex;
  justify-content: center;
  gap: 12px;
  margin-top: 8px;
}
.update-actions button {
  border: none;
  border-radius: 4px;
  padding: 9px 18px;
  font-size: 14px;
  font-weight: 500;
  transition: background-color 0.2s ease;
}
.update-actions button:first-child {
  background-color: #f5f5f5;
  color: #666;
}
.update-actions button:first-child:hover:not(:disabled) {
  background-color: #e8e8e8;
}
.update-actions button:last-child {
  background-color: #007aff;
  color: #fff;
}
.update-actions button:last-child:hover:not(:disabled) {
  background-color: #0066cc;
}
.btn-force {
  background-color: #ff4d4f !important;
}
.btn-force:hover:not(:disabled) {
  background-color: #e03e3e !important;
}
.update-actions button:disabled {
  opacity: 0.7;
  cursor: not-allowed;
}

/* 核心：独立重启提示（居中显示，简洁样式） */
.restart-tip {
  position: fixed;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  width: 180px;
  height: 180px;
  background-color: rgba(0, 0, 0, 0.8);
  border-radius: 12px;
  z-index: 9999;
}
.restart-icon {
  font-size: 40px;
  color: #fff;
  margin-bottom: 15px;
  animation: rotate 1.5s linear infinite;
}
.restart-text {
  font-size: 16px;
  color: #fff;
  text-align: center;
  line-height: 1.5;
  padding: 0 10px;
}
/* 重启图标旋转动画 */
@keyframes rotate {
  from {
    transform: rotate(0deg);
  }
  to {
    transform: rotate(360deg);
  }
}

/* 小屏幕适配 */
@media (max-width: 320px) {
  .update-dialog {
    padding: 18px 14px;
  }
  .update-title {
    font-size: 16px;
    margin-bottom: 14px;
  }
  .restart-tip {
    width: 150px;
    height: 150px;
  }
  .restart-icon {
    font-size: 32px;
  }
  .restart-text {
    font-size: 14px;
  }
}
</style>
